Claude Code: Complete Guide From Beginner to Power User 2026

You've probably seen people on social media claiming they "haven't written a single line of code by hand in months." Sounds like BS, right?

Except the person saying it is Boris Cherny, the guy who literally created Claude Code (more). He ships 200-300 pull requests a month, and Claude writes 100% of his code. Not some of it. All of it.

Claude Code is the AI coding tool that went viral in 2025, and it's now responsible for 4% of all public GitHub commits. But here's the thing most people miss: it's not just for coders. Half of Anthropic's sales team uses it weekly. Designers, product managers, data scientists… pretty much all of them use it every day.

Well, we watched seven of the best videos on Claude Code, from Boris himself to Meta engineers and AI automation founders, and organized every useful insight into one guide. No fluff, no filler. Just the stuff that'll make you more productive, ordered so each idea builds on the last.

Let's get into it.

First, What Is Claude Code?
Why This Moment Is Different: A 70-Year Arc in 5 Minutes
Getting Started: The Workspace Concept
The "Second Brain" That Changes Everything
Context Stacking: The Real Secret
The Claude.md File: Your AI's Instruction Manual
Plan Mode: "Once the Plan Is Good, the Code Is Good"
Seeing It In Action: Liam's Competitor Analysis Demo
Skills, Commands, and Hooks: Your Reusable Toolkit
Running Multiple Claudes in Parallel
Give Claude a Way to Verify Its Own Work
Agent Teams: When One Claude Isn't Enough
Cowork: Claude Code for Non-Coders
Power-User Tips Worth Knowing
Where This Is All Going

First, What Is Claude Code?

Claude Code is a tool from Anthropic (the company behind Claude) that lets you talk to an AI in plain English and have it take actions on your computer. Write code, organize files, search the web, send emails, build spreadsheets… basically anything you'd do yourself, but delegated to an AI agent.

An "agent," by the way, is an AI that doesn't just chat with you. It can actually use tools on your computer and interact with the world. That's the key difference from ChatGPT or regular Claude. When you ask Claude Code to do something, it doesn't just give you text back. It opens files, runs commands, browses the web, and creates things.

Boris originally built it as an internal tool at Anthropic. It wasn't even supposed to be a product. But then something surprising happened: people started using it for way more than coding. Organizing files. Writing status updates. Automating tedious busywork. The use cases just kept expanding.

As Boris put it at the AI Engineer World's Fair: Claude Code is intentionally simple, intentionally general. Anthropic doesn't try to put a bunch of scaffolding in the way because "we actually just don't know what the right UX is. So we're starting simple."

That's worth pausing on. The people who built this tool are still discovering what it's for. Which means you have just as much opportunity to figure out creative ways to use it as they do.

Why This Moment Is Different: A 70-Year Arc in 5 Minutes

To understand why Claude Code feels like such a leap, it helps to see where programming came from. Boris gave a fascinating talk at the AI Engineer World's Fair tracing the entire history of how humans interact with computers.

In the 1950s, programming meant punching physical holes in cardboard cards. Boris's grandfather was one of the first programmers in the Soviet Union, and his mom grew up drawing over stacks of punch cards with crayons. That was what "code" looked like.

Then came Ed, the first text editor, built for teletype machines that literally printed on paper. No cursor, no scrollback, no undo. You can still type ed on a modern Mac; it ships with every Unix system and has for 50 years. After Ed came Vim, then Emacs, then SmallTalk 80, which introduced the first graphical programming interface and had live reload in 1980. (Something React developers are still fighting with today.)

Visual Basic brought graphical coding to the mainstream in 1991. Eclipse added type-ahead auto-complete using static analysis. Then GitHub Copilot introduced AI-powered code suggestions. And Devin was probably the first tool to prove you could write code using natural language instead of a programming language.

Each jump took less time than the one before. And Boris's takeaway is striking: programming languages have started to converge and level out, but the experience of programming is still on an exponential curve. We're in the middle of the steepest part.

This is why Anthropic keeps Claude Code intentionally simple and unopinionated. They're a model company, not a product company. They want you to experience the raw capability of the model, figure out what workflows emerge naturally, and build the right product around what people actually need, not what a product manager guessed in advance.

Boris frames this as a philosophy: "The more general model always wins, and the model increases in capability exponentially." That belief trickles into everything. Keep the tool general. Let users discover the use cases. Stay out of the way.

Getting Started: The Workspace Concept

If you've never used Claude Code before, here's the simplest mental model: think of it as hiring a new employee.

Liam Ottley, who trains his entire team on Claude Code, puts it this way: a digital employee needs tools, access, context, and knowledge about what it's doing. You wouldn't throw a new hire into the deep end with zero onboarding. Same goes for Claude Code.

The way you onboard it is by setting up a workspace, which is just a folder on your computer containing everything Claude needs to do its job. Liam breaks this down into a few key pieces:

A claude.md file (the "orientation doc" that tells Claude who you are, what this workspace is for, and how everything fits together)
A context folder (background info about your business, your role, your current strategy, and any relevant data)
A commands folder (reusable prompts that automate specific tasks; more on this in a bit)
A skills folder (plugins that teach Claude new capabilities)
An outputs folder (where Claude puts finished work)

You don't need to be a developer to set this up. It's literally just folders and text files. Open VS Code (a free code editor), open the folder, and type claude in the terminal to start.

One shortcut worth setting up immediately: Liam recommends creating quick-launch aliases so you can type CR (for "Claude Risky," which is the skip-permissions mode) and it automatically starts Claude Code AND runs your priming command. More on what priming means in a second.

The "Second Brain" That Changes Everything

Here's where most people go wrong with AI tools. They treat them like a chatbot.

John Kim, a staff engineer at Meta, described the problem perfectly: you open ChatGPT, paste some context, explain your project from scratch, get a generic response, then spend 10 minutes going back and forth fixing it. "This may work," he says, "but it's not automation. It's really just moving the work around."

Every time you start a new ChatGPT conversation, you're re-onboarding an employee who has amnesia. You explain your project structure. Again. Your team's priorities. Again. The decision you made last week. Again.

John's solution: build a "second brain" inside Claude Code. Because Claude Code runs locally on your computer (not in a browser tab), it can read your actual files, your actual code, your actual project history. And you can build a knowledge base that grows over time.

The workflow is dead simple:

After every working session, tell Claude Code: "Update what we just did to my project knowledge base."
Claude writes a summary and saves it locally.
Next time you start Claude Code, it reads that knowledge base and picks up right where you left off.

"Weeks later," John says, "Claude doesn't need any explanation. It already has the history of the project."

This is the insight that separates casual AI users from people who actually save hours: context beats prompting. You don't need to write the perfect prompt. You need to build a system that remembers.

Context Stacking: The Real Secret

That idea, context over prompting, is worth going deeper on. Because it's the foundation everything else builds on.

Liam Ottley visualizes it as layers. At the bottom, you have your claude.md file (the workspace overview). On top of that, information about your business. Then info about you and your role. Then your current strategy. Then your most recent data, like website analytics or sales numbers.

Every time you start a fresh Claude Code session, you "prime" it by having it read through all these layers. That's what the /prime command does: it loads your context, reads the claude.md, reads your context folder, and gives you a quick summary confirming it understands the environment.

Why does this matter? Claude Code has a 200,000-token context window. (Tokens are the units AI models use to process text; 200K tokens is roughly 150,000 words, or about two full novels.) That sounds like a lot, but here's the catch: the more of that window you fill up with rambling chat messages, the worse the AI performs. Your instructions get diluted. The AI loses focus. This is called "context bloat."

The solution is to keep your conversations short and start fresh often. Prime, do a task, close it out. Prime again, do the next task. That way you're always working with a sharp, focused AI that has plenty of room to think.

As John Kim puts it: "Context is king. Context is best served fresh and condensed."

The Claude.md File: Your AI's Instruction Manual

The claude.md file deserves its own section because it's the single most important file in your setup. Boris calls it "the one thing that you should all be updating all the time."

Think of it as a living instruction manual for your AI. It tells Claude what this workspace is for, what tools are available, what conventions to follow, and what mistakes to avoid.

At Anthropic, Boris's team shares a single claude.md for their entire repo. They check it into Git (the version control system that tracks code changes). The whole team contributes to it multiple times a week. And here's the key habit: anytime they see Claude do something incorrectly, they add it to the claude.md so it doesn't happen again.

Boris compares this to a system he used at Meta: every code review, he logged common issues in a spreadsheet. Once the same issue came up five or ten times, he'd write an automated rule to catch it. Claude.md is the AI equivalent. You never have to give the same feedback twice.

Now, a critical tip from Simon Scrapes: "Point, don't dump." Most beginners cram their entire brand guide, all their content pillars, audience research, and example posts into the claude.md. Don't do that. Keep it lean (20-30 lines) and point Claude to where the detailed info lives, like separate skills or reference files. Claude reads the claude.md every single session. If it's bloated, you're eating into that 200K context window before you even ask your first question.

What it should include: the purpose of the workspace, a list of available commands and skills, key conventions and rules, and pointers to where more detailed context lives.

What it should NOT include: your entire brand guide, full project documentation, or lengthy examples.

Plan Mode: "Once the Plan Is Good, the Code Is Good"

This might be the most underrated feature in all of Claude Code.

When you start a task, hit Shift+Tab (or use the /plan approach). This puts Claude into "plan mode," where it maps out what it's going to do without actually doing anything yet. You review the plan, go back and forth until it looks right, and then let Claude execute.

Boris says he uses plan mode for almost all his sessions. His reasoning is simple: with Opus 4.5 (and now 4.6), once the plan is solid, Claude can execute it almost perfectly. "Once the plan is good, the code is good."

This works because planning and executing use different "muscles." When Claude plans, it's thinking strategically about the whole picture: what files to change, in what order, what edge cases to watch for. When it executes, it's focused on implementation. Separating these steps produces dramatically cleaner results.

Liam Ottley's workspace template bakes this into a two-step workflow:

Run /create-plan with a description of what you want
Review the plan (Claude saves it as a file you can inspect)
Run /implement to execute it

This isn't just for code. Liam uses it to build entire automation workflows: competitor analysis tools, podcast research systems, market scanning commands. The planning step lets Claude figure out what scripts to write, what APIs to connect to, and what the output format should be, all before touching a single file.

Seeing It In Action: Liam's Competitor Analysis Demo

This gets concrete fast. In his video, Liam walks through building a full competitor analysis automation from scratch, and it shows exactly how planning, skills, and external tools chain together.

He types /create-plan and describes what he wants: a new command called /analyze-competitor that takes a person or podcast name and produces a full competitive breakdown. The workflow should use Claude's built-in deep research to find the target's links and background, connect to Apify (a platform with ready-made web scrapers) through an MCP integration to pull real-time YouTube data on their latest 20 videos, generate a markdown research report, and then use a PowerPoint skill to turn the report into a presentation.

MCP, by the way, stands for Model Context Protocol. It's a standard way for AI tools to connect to external services. Think of it like a universal adapter. Instead of building custom code to talk to YouTube, you plug in an MCP connector and Claude knows how to use it.

Claude creates a detailed plan breaking down every step: which APIs to connect, which skills to install, what the command file should contain, how to handle the output. Liam reviews it, runs /implement, and Claude builds the whole thing. It downloads the PowerPoint skill from a marketplace, configures the Apify MCP connector, and writes the multi-step command file.

The finished product: he types /analyze-competitor Lenny's Podcast, Claude kicks off a deep research agent in the background, scrapes YouTube data through Apify, compiles a markdown report with positioning, episode frequency, engagement metrics, and then turns it all into a presentation with real data in every slide: average views, SWOT analysis, strategic recommendations.

The whole process, from a paragraph of instructions to a repeatable one-command automation, took about 30 minutes. And now he can run it on any competitor, any time, with a single slash command. That's the power of combining plan mode with skills and external integrations.

Skills, Commands, and Hooks: Your Reusable Toolkit

Once you've got context stacking and plan mode down, the next level is building reusable workflows. Claude Code has three tools for this, and Simon Scrapes has the clearest breakdown of how they differ:

Slash commands are like pressing a button. You type /linkedin-posts and Claude runs a predefined set of instructions. They live as simple text files in your commands folder. Each one is basically a prompt template you've saved so you never have to retype it.
Skills are smarter. Instead of you triggering them manually, Claude reads the skill description and decides when to use it on its own. For example, a "brand voice" skill might say "always use these guidelines when writing social media content." Claude sees it's writing social content and automatically applies the skill. Think of skills as standing instructions that kick in when relevant.
Hooks don't use AI at all. They're simple automated checks that run programmatically. For example, a "banned words checker" hook could scan every output file for specific words you want to avoid, like jargon your audience wouldn't understand. Zero tokens spent.

John Kim's approach to skills is beautifully simple: do a task manually with Claude just once, step by step. Then say, "Turn what we did into a skill." Claude creates the skill file for you. Now that workflow is automated forever.

He built skills for PR splitting (breaking large code changes into logical chunks), incident investigation (searching release logs for what broke and why), and status update generation. "This one skill has saved me hours of time," he says about his investigation workflow.

These three tools work together beautifully. You type a slash command, which triggers a workflow. That workflow automatically invokes relevant skills. And hooks run quality checks in the background. The full pipeline fires from a single command.

Running Multiple Claudes in Parallel

Here's where things get wild.

Boris doesn't run one Claude Code session at a time. He runs five to ten. Sometimes from his terminal. Sometimes from the web. Sometimes from his phone. He kicks off tasks in the morning before he even gets out of bed.

The workflow: start a task in one tab. While Claude's thinking, open a second tab and start another task. Then a third. Once you run out of immediate things to kick off, go back to the first tab. Check the plan, give feedback, let it execute. Bounce to the next one.

Boris describes this as "tending to your Claudes". You're not going deep on one thing. You're a generalist overseeing multiple agents, making sure they're unblocked, answering their questions, and nudging them in the right direction.

Someone will inevitably say: "But I can do most of those tasks faster myself." Boris addresses this directly. Yes, you can do one task faster. But can you do five tasks simultaneously? The speed advantage comes from parallelism, not from any single task being faster.

John Kim took this to the extreme: he built and deployed an entire web app entirely from his phone. No laptop. Just Claude Code through a mobile app while doing errands around the house. He set up a Next.js project, pushed to GitHub, deployed to Vercel, and connected a custom domain, all from his phone while waiting for junk removal.

His honest verdict? You can start tasks, steer direction, and make progress on the go. But for QA and detailed review, you still want a computer. The real power is kicking things off from anywhere and checking in later.

Give Claude a Way to Verify Its Own Work

This is Boris's top tip for getting better results, and it's surprisingly overlooked.

Imagine you're a painter who has to paint with a blindfold on. You might get the general shape right, but the details will be off. Now imagine you can take the blindfold off, look at your work, and fix it. Night and day difference.

That's what verification does for Claude. If Claude can see the output of its work (through a browser screenshot, a test result, or a simulator), it can catch its own mistakes and iterate. The first attempt might be okay. The second or third will be great.

For code, this means: run the tests, start a dev server, take screenshots through the browser extension. For non-code work, it might mean having Claude review its own output against a checklist, or using the fact-checking technique from Simon's 10 tips: tell Claude to "double-check every claim and statistic, and make a table of what you could and couldn't verify, including the source."

Boris's three pillars for getting better results, in order of importance:

Use the smartest model (Opus 4.5 or 4.6 with extended thinking)
Maintain a good claude.md
Give Claude a way to verify its output

On that first point, here's a counterintuitive insight: Opus is bigger and slower per token than Sonnet, but because it's smarter, it needs fewer attempts and uses fewer total tokens. It often ends up being both faster and cheaper overall than using a "lighter" model.

Agent Teams: When One Claude Isn't Enough

Everything above works with a single Claude Code session. But some projects need more horsepower.

Simon Scrapes breaks down the problem: the longer a single agent runs, the worse it gets. It forgets context, introduces bugs, and forces you to repeat yourself. This is because of that 200K token limit. As the conversation grows, older context gets compressed and summarized, and key details can get lost.

Power users found a workaround: sub-agents. You have a main Claude session that delegates specialized tasks to smaller, focused sessions. A researcher sub-agent does web research. A reviewer sub-agent checks the output. Each one has its own fresh context window.

But sub-agents have a limitation: they can only talk to the parent agent. The researcher can't talk to the reviewer. Everything has to flow through the main agent, which becomes a bottleneck.

That's where agent teams come in. They're Claude Code's new (still experimental) feature that lets multiple Claude instances work in parallel AND talk to each other through a shared task list. Each teammate has its own context window, can pull tasks from the shared list, and can communicate directly with other teammates.

To enable it, you add one line to your settings file: "claude_code_experimental_agent_teams": true. Then restart Claude Code and tell it to create a team.

But here's the key: don't use agent teams for everything. Simon has a useful rating system:

2 out of 10 (single agent is fine): Writing a few LinkedIn posts. Limited scope, no cross-collaboration needed.
6 out of 10 (agent teams help): Repurposing a video into a blog post, carousel, and newsletter. Each writer needs to coordinate angles so content doesn't contradict or duplicate.
8 out of 10 (agent teams shine): Building a complex web app where the API layer, front-end, and testing suite all need to stay in sync.

The rule of thumb: start simple, graduate to sub-agents as projects get complex, then reach for agent teams when cross-collaboration is genuinely necessary.

Cowork: Claude Code for Non-Coders

Everything so far involves a terminal (the text-based interface where you type commands). If that sounds intimidating, Boris has good news.

Claude Cowork is a new product that puts the same Claude Code engine behind a simple visual interface. Download the Claude desktop app, click the "Cowork" tab, and you're in. No terminal required.

Under the hood, it's running the same agent that makes Claude Code powerful. But instead of typing commands, you just describe what you want in plain English.

In his demo, Boris showed Cowork:

Renaming receipt files to match the dates on the actual receipts (it reads the PDFs, extracts dates, and renames the files)
Turning those receipts into a spreadsheet with all the line items extracted
Opening Google Sheets in the browser, creating a new sheet, and pasting the data in (Claude literally controls your browser, clicking and typing like a person would)
Opening Gmail and drafting an email with the sheet attached

The big mindset shift: Cowork operates with your files and your apps. It's not trapped in a chat window. It can use any tool through your browser, interact with any website, and create files directly on your computer.

One detail worth highlighting: when Cowork hits something ambiguous, it doesn't just guess. It asks you. Boris calls this "reverse elicitation", and it's baked into the model. In the demo, one receipt was missing a date, so instead of inventing one, Claude paused and asked Boris what to do. This matters a lot when you're trusting an AI to touch your actual files. You want it to check in when it's unsure rather than confidently do the wrong thing.

And because this is an AI operating on your actual computer (not a sandboxed chat window), Anthropic put serious work into safety guardrails. There's a whole virtual machine running under the hood so actions don't affect your broader system. As of recently, there's deletion protection; if Cowork tries to delete a file, it prompts you first. And because Cowork interacts with the internet through your browser, they've built in protections against prompt injection (where a malicious website could try to trick the AI into doing something you didn't ask for). Boris is transparent that it's not perfect yet, which is part of why they released it early: they want to study real-world usage to keep improving safety.

Boris's recommendation for getting started with Cowork: don't try to customize it. Install it, install the Chrome extension, and just start handing it tasks. Mount a folder, tell it to organize things, and see what happens. Keep it simple at first.

He also uses it for team management: every week, he has Cowork look at a team spreadsheet and message any engineer on Slack whose status column is empty. He kicks it off, goes and gets coffee, and comes back to a team that's been nudged to update their status. Somewhere, middle managers everywhere just felt a chill.

Power-User Tips Worth Knowing

A few more tricks from the videos that didn't fit neatly above but are too good to skip:

Restore conversation history. If you closed a Claude Code session and need to pick up where you left off, you can ask Claude to search your past conversations. Type something like "what have we spoken about in the last week?" and it'll pull up summaries of previous sessions. You can then dive back into any topic.
Get past paywalls and blocked sites. Claude Code can't access every website (Reddit and some news sites are blocked). A clever workaround: install the Gemini command line tool as a fallback. When Claude hits a block, it routes the request through Gemini, which has broader web access. You set this up as a skill so it happens automatically.
30 days of research in 30 seconds. There's a skill called "Last 30 Days" that scans Reddit, X, and the web for discussions about any topic over the past month. Simon used it to instantly learn that JSON-structured prompts dominate a specific AI image tool (something that would have taken hours of manual research). It pulled from six threads, 240 upvotes, and 30 web pages in under three minutes.
Copy directly to clipboard. Tired of copying AI output and losing all the formatting? Tell Claude to copy the result directly to your clipboard in the native format of whatever platform you're posting to. For LinkedIn, that means emoji bullets instead of markdown. Paste it and it looks perfect.
Built-in commands to know: /clear compresses your conversation history and frees up context. /usage shows how much of your plan limit you've burned this session and this week. /stats gives you fun metrics like total sessions and token usage (it'll compare your usage to the length of classic novels, which is a genuinely delightful touch).

Where This Is All Going

Boris is honest about the future: "I plan in like a one-week timeline." The models are advancing exponentially, and "my puny human meat brain can't grapple with exponential."

But here's what he does expect: the tedious stuff, connecting apps, shuffling data, filing paperwork, will be fully handled by AI agents. You focus on the work you enjoy. The agents handle everything else.

John Kim sees a similar future: a world where you spend a day designing and planning, then let agents execute for hours or days while you review the results. Not "vibe coding," which he thinks needs a new name. More like "agentic engineering," where the humans design the system and the AI does the implementation.

Boris compares this moment to the early days of the App Store. The first apps were beer-drinking simulators and fart buttons. Nobody predicted Uber or DoorDash or TikTok. We're at that same inflection point with AI agents, and the use cases that matter most probably haven't been invented yet.

The one thing every person we watched agrees on? Get your hands dirty now. Don't wait for the perfect tutorial or the perfect setup. Start simple. See what works. Build from there.

As Boris says: "There's no one right way to use this stuff. It's like a choose-your-own-adventure book. Just see what works for you."

Quick-Start Checklist:

Install Claude Code (npm install -g @anthropic-ai/claude-code)
Create a workspace folder with claude.md, context, commands, and outputs subfolders
Write your claude.md (keep it under 30 lines; point to detail, don't dump it)
Set up a /prime command to load context at the start of every session
Start every task in plan mode (Shift+Tab) before letting Claude execute
After every session, update your knowledge base ("update what we just did")
Run multiple sessions in parallel; tend to your Claudes
Give Claude a way to verify its own output (tests, screenshots, browser)
When projects get complex, graduate to sub-agents or agent teams

Videos Referenced: